import logging # 新增导入
from flask import Flask
from flask_cors import CORS
from flask_socketio import SocketIO, emit
import os
import sys
import threading
import uuid
from typing import Dict, Any, List

# 添加项目根目录到Python路径
sys.path.append(os.path.dirname(os.path.abspath(__file__)))

from core.config import get_config
from core.logger import get_logger, cleanup_old_logs
from core.html_converter import get_html_converter
from core.wechat_publisher import get_wechat_publisher
from aicore.Spark_client import get_spark_client
from aicore.qwen_client import get_qwen_client
from aicore.kimi_client import get_kimi_client
from route import register_main_routes, register_api_routes, register_article_routes, register_wechat_routes
from tools.trendradar.trendradar_client import get_filtered_trends


class HotTopicApp:
    """
    HotTopic 主应用类
    """

    def __init__(self):
        """
        初始化应用
        """
        self.logger = get_logger(log_level=logging.DEBUG) 
        self.app = Flask(__name__)
        CORS(self.app)  # 启用跨域支持

        # 初始化SocketIO
        self.socketio = SocketIO(self.app, cors_allowed_origins="*")

        # 任务状态管理
        self.task_status = {}  # 存储任务状态

        # 初始化组件
        self.config = get_config()
        self.logger = get_logger(log_level=logging.DEBUG) # 修改此处，强制设置为DEBUG级别
        self.html_converter = get_html_converter()
        self.wechat_publisher = get_wechat_publisher()

        # 根据配置选择AI客户端
        ai_model = self.config.get_ai_model()
        if ai_model == 'qwen':
            self.ai_client = get_qwen_client('qwen')
            self.logger.info("使用Qwen AI客户端")
        elif ai_model == 'kimi':
            self.ai_client = get_qwen_client('kimi')
            self.logger.info("使用Kimi AI客户端")
        else:
            self.ai_client = get_spark_client()
            self.logger.info("使用Spark AI客户端")

        # 注册路由
        self._register_routes()

        # 清理旧日志
        cleanup_old_logs(keep_days=self.config.get_max_log_files())

        self.logger.info("应用初始化完成")

    def _register_routes(self):
        """
        注册路由
        """
        # 注册各个模块的路由
        register_main_routes(self.app)
        register_api_routes(self.app, self)
        register_article_routes(self.app, self)
        register_wechat_routes(self.app, self)

        # 注册SocketIO事件
        self._register_socketio_events()

    def _register_socketio_events(self):
        """
        注册SocketIO事件
        """

        @self.socketio.on('connect')
        def handle_connect():
            self.logger.info('客户端已连接')

        @self.socketio.on('disconnect')
        def handle_disconnect():
            self.logger.info('客户端已断开连接')

    async def generate_article_async(self,
                                     title: str,
                                     task_id: str,
                                     use_catchy_title: bool = True,
                                     ai_model: str = 'qwen',
                                     url: str = '',
                                     platform: str = ''):
        """
        异步生成多平台适配的文章（标题+内容）

        Args:
            title: 原始标题
            task_id: 任务ID
            use_catchy_title: 是否启用趋势分析与爆款标题生成
            ai_model: AI模型选择 ('qwen' 或 'kimi')
            platforms: 目标发布平台列表，例如 ['wechat', 'weibo', 'xiaohongshu']
        """

        if platform is None:
            platform = 'wechat'

        self.logger.info(f"待生成平台列表: {platform}")  # 调试日志

        try:
            # 选择AI客户端
            if ai_model == 'kimi':
                ai_client = get_qwen_client('kimi')
                self.logger.info(f"使用Kimi AI客户端生成多平台内容: {title}")
            else:
                ai_client = get_qwen_client('qwen')
                self.logger.info(f"使用Qwen AI客户端生成多平台内容: {title}")

            hot_item = {
                "title": title,
                "url": url,
                "platform": platform
            }

            # === 阶段1：趋势分析 + 多平台标题生成 ===
            self.task_status[task_id] = {
                'status': 'analyzing',
                'message': f'正在分析热点趋势并生成各平台爆款标题...',
                'progress': 20
            }
            self.socketio.emit('task_update', {
                'task_id': task_id,
                'status': 'analyzing',
                'message': f'正在分析热点趋势并生成各平台爆款标题...',
                'progress': 20
            })

            # 调用多平台生成主函数
            multi_platform_result = ai_client.generate_multi_platform_content(
                hot_item=hot_item,
                platform=platform,
                use_trend_analysis=use_catchy_title  # 是否启用趋势分析
            )

            if not multi_platform_result:
                raise Exception("多平台内容生成失败：返回为空")

            # === 阶段2：开始生成各平台内容 ===
            self.task_status[task_id] = {
                'status': 'generating_article',
                'message': '正在为各平台生成定制化内容...',
                'progress': 50
            }
            self.socketio.emit('task_update', {
                'task_id': task_id,
                'status': 'generating_article',
                'message': '正在为各平台生成定制化内容...',
                'progress': 50
            })

            # === 阶段3：保存所有平台内容 ===
            self.task_status[task_id] = {
                'status': 'saving',
                'message': '正在保存多平台文章...',
                'progress': 80
            }
            self.socketio.emit('task_update', {
                'task_id': task_id,
                'status': 'saving',
                'message': '正在保存多平台文章...',
                'progress': 80
            })

            # 创建保存目录
            articles_dir = os.path.join(os.path.dirname(__file__), 'articles')
            if not os.path.exists(articles_dir):
                os.makedirs(articles_dir)

            from datetime import datetime
            import re

            saved_files = []

            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            platforms_to_generate = list(multi_platform_result.keys())

            for platform in platforms_to_generate:
                result = multi_platform_result.get(platform)
                if not result or not result.get("content"):
                    self.logger.warning(f"{platform} 内容生成失败，跳过保存")
                    continue

                final_title = result["title"]
                content = result["content"]

                # 生成安全文件名
                safe_title = re.sub(r'[<>:"/\\|?*]', '_', final_title)
                safe_title = re.sub(r'[\s]+', '_', safe_title)
                safe_title = safe_title[:30]  # 控制长度

                filename = f"{timestamp}_{platform}_{safe_title}.md"
                file_path = os.path.join(articles_dir, filename)

                # 写入Markdown文件
                with open(file_path, 'w', encoding='utf-8') as f:
                    f.write(f"# {final_title}\n\n")  # 添加标题
                    f.write(content)

                saved_files.append({
                    'platform': platform,
                    'title': final_title,
                    'filename': filename,
                    'file_path': file_path
                })

                self.logger.info(f"已保存 {platform} 平台文章: {file_path}")

            # === 任务完成 ===
            self.task_status[task_id] = {
                'status': 'completed',
                'message': f'多平台文章生成完成（共 {len(saved_files)} 个平台）',
                'progress': 100,
                'data': {
                    'original_title': title,
                    'platform_results': saved_files
                }
            }

            self.socketio.emit('task_update', {
                'task_id': task_id,
                'status': 'completed',
                'message': f'多平台文章生成完成（共 {len(saved_files)} 个平台）',
                'progress': 100,
                'original_title': title,
                'platform_results': saved_files
            })

            self.logger.info(f"多平台文章生成完成: {title} -> {len(saved_files)} 个平台")

        except Exception as e:
            error_msg = f'生成文章失败: {str(e)}'
            self.task_status[task_id] = {
                'status': 'failed',
                'message': error_msg,
                'progress': 0
            }
            self.socketio.emit('task_update', {
                'task_id': task_id,
                'status': 'error',
                'error': error_msg,
                'progress': 0
            })
            self.logger.error(f"异步生成多平台文章失败: {e}")

    def start_article_generation(self, title: str, url: str = '', platform: str = '', use_catchy_title: bool = True,
                                 ai_model: str = 'qwen') -> str:
        """
        启动文章生成任务

        Args:
            title: 原始标题
            use_catchy_title: 是否生成爆款标题
            ai_model: AI模型选择 ('qwen' 或 'spark')

        Returns:
            str: 任务ID
        """
        task_id = str(uuid.uuid4())

        # 初始化任务状态
        self.task_status[task_id] = {
            'status': 'started',
            'message': '任务已启动...',
            'progress': 10
        }

        # 启动异步任务
        def _run_async_in_thread():
            import asyncio
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            loop.run_until_complete(
                self.generate_article_async(title, task_id, use_catchy_title, ai_model, url,platform,))
            loop.close()

        thread = threading.Thread(
            target=_run_async_in_thread
        )
        thread.daemon = True
        thread.start()

        return task_id

    def generate_article_from_content_async(self, content: str, task_id: str, ai_model: str = 'qwen'):
        """
        根据多文字内容异步生成文章

        Args:
            content: 输入的多文字内容
            task_id: 任务ID
            ai_model: AI模型选择 ('qwen', 'kimi' 或 'spark')
        """
        try:
            # 根据ai_model参数选择AI客户端
            if ai_model == 'spark':
                ai_client = get_spark_client()
                self.logger.info(f"使用Spark AI客户端根据多文字内容生成文章")
            elif ai_model == 'kimi':
                ai_client = get_qwen_client('kimi')
                self.logger.info(f"使用Kimi AI客户端根据多文字内容生成文章")
            else:
                ai_client = get_qwen_client('qwen')
                self.logger.info(f"使用Qwen AI客户端根据多文字内容生成文章")

            # 更新任务状态
            self.task_status[task_id] = {
                'status': 'generating_title',
                'message': f'正在使用{ai_model.upper()}分析内容并生成标题...',
                'progress': 20
            }
            self.socketio.emit('task_update', {
                'task_id': task_id,
                'status': 'generating_title',
                'message': f'正在使用{ai_model.upper()}分析内容并生成标题...',
                'progress': 20
            })

            # 根据多文字内容生成文章和标题
            article_content, final_title = ai_client.generate_article_from_content(content)

            # 更新任务状态：开始生成文章
            self.task_status[task_id] = {
                'status': 'generating_article',
                'message': '正在生成文章内容...',
                'progress': 50
            }
            self.socketio.emit('task_update', {
                'task_id': task_id,
                'status': 'generating_article',
                'title': final_title if final_title else '生成中...',
                'message': '正在生成文章内容...',
                'progress': 50
            })

            if article_content and final_title:
                # 更新任务状态
                self.task_status[task_id] = {
                    'status': 'saving',
                    'message': '正在保存文章...',
                    'progress': 80
                }
                self.socketio.emit('task_update', {
                    'task_id': task_id,
                    'status': 'saving',
                    'message': '正在保存文章...',
                    'progress': 80
                })

                # 保存文章
                articles_dir = os.path.join(os.path.dirname(__file__), 'articles')
                if not os.path.exists(articles_dir):
                    os.makedirs(articles_dir)

                from datetime import datetime
                import re

                # 生成安全的文件名
                safe_title = re.sub(r'[<>:"/\\|?*]', '_', final_title)
                safe_title = re.sub(r'[\s]+', '_', safe_title)
                if len(safe_title) > 50:
                    safe_title = safe_title[:50]

                timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
                filename = f"{timestamp}_{safe_title}.md"
                file_path = os.path.join(articles_dir, filename)

                # 写入文件
                with open(file_path, 'w', encoding='utf-8') as f:
                    f.write(article_content)

                # 任务完成
                self.task_status[task_id] = {
                    'status': 'completed',
                    'message': '文章生成完成！',
                    'progress': 100,
                    'data': {
                        'title': final_title,
                        'filename': filename,
                        'file_path': file_path
                    }
                }
                self.socketio.emit('task_update', {
                    'task_id': task_id,
                    'status': 'completed',
                    'message': '文章生成完成！',
                    'progress': 100,
                    'final_title': final_title,
                    'filename': filename,
                    'file_path': file_path
                })

                self.logger.info(f"文章生成完成（多文字内容）: {final_title}")
            else:
                # 任务失败
                self.task_status[task_id] = {
                    'status': 'failed',
                    'message': 'AI文章生成失败',
                    'progress': 0
                }
                self.socketio.emit('task_update', {
                    'task_id': task_id,
                    'status': 'error',
                    'error': 'AI文章生成失败',
                    'progress': 0
                })

        except Exception as e:
            # 任务异常
            self.task_status[task_id] = {
                'status': 'failed',
                'message': f'生成文章失败: {str(e)}',
                'progress': 0
            }
            self.socketio.emit('task_update', {
                'task_id': task_id,
                'status': 'error',
                'error': f'生成文章失败: {str(e)}',
                'progress': 0
            })
            self.logger.error(f"异步生成文章失败（多文字内容）: {e}")

    def start_article_generation_from_content(self, content: str, ai_model: str = 'qwen') -> str:
        """
        启动根据多文字内容生成文章的任务

        Args:
            content: 输入的多文字内容
            ai_model: AI模型选择 ('qwen', 'kimi' 或 'gemini')

        Returns:
            str: 任务ID
        """
        task_id = str(uuid.uuid4())

        # 初始化任务状态
        self.task_status[task_id] = {
            'status': 'started',
            'message': '任务已启动...',
            'progress': 10
        }

        # 启动异步任务
        thread = threading.Thread(
            target=self.generate_article_from_content_async,
            args=(content, task_id, ai_model)
        )
        thread.daemon = True
        thread.start()

        return task_id

    def run(self, host='127.0.0.1', port=5000, debug=False):
        """
        运行应用

        Args:
            host: 主机地址
            port: 端口号
            debug: 调试模式
        """
        self.logger.info(f"启动Hot TopicAPP服务: http://{host}:{port}")
        self.socketio.run(self.app, host=host, port=port, debug=debug, allow_unsafe_werkzeug=True)

    def create_app(self)-> Flask:
        """
        创建Flask应用实例

        Returns:
            Flask: Flask应用实例
        """
        ht_app = HotTopicApp()
        return ht_app.app


if __name__ == '__main__':
    # 创建应用实例
    ht_app = HotTopicApp()

    # 运行应用
    ht_app.run(debug=True)
